// Style note 3/3:
// internal objects & functions are in under_score form.
// public functions are in interCaps.

var bAnyPrefLocked = false;

// --- Preference objects ---
function preference(default_value) {
	this.default_value = default_value;
	this.user_value = null;
	this.locked = false;
};

function pref_array(parent) {
	this.parent = parent;
};

function plat() {
	this.windows=false;
	this.mac=false;
	this.unix=false;
};

platform = new plat();

// --- Preference initialization functions ---
//  -- Pass a string and value to a pref function, e.g.
//      user_pref("browser.startup.homepage", "abc");
//  -- It parses the string and defines branches of the prefs
//      object as necessary.
//  -- Note assumptions:
//      Root of the tree is prefs.
//      Every branch is a pref_array and leaves are preference objects.
//
function next_field(str, index)
{
	var i = str.indexOf('.', index);
	if (i == -1)
		i = str.length;
	return str.substring(index, i)
}

function init_prefarray(prefix, name, parent)
{
	if (typeof(prefix[name]) == "undefined") {
		// --ML mime-type hack requiring knowledge of array structure...
		if (parent == "mime" || parent == "static_mime")
			prefix[name] = new mime_type1(prefix);
		else
			prefix[name] = new pref_array(prefix);
	}
}

function init_pref(prefix, name)
{
	if (typeof(prefix[name]) == "undefined")
		prefix[name] = new preference(null);
}

// returns the preference object named by prefname
function init_preftree(prefname)
{
	var index = 0;
	var prefix = prefs;
	var parent = "";
	while (index < prefname.length)
	{
		field = next_field(prefname, index);
		index = index + field.length + 1;
		
		if (index >= prefname.length) {
			init_pref(prefix, field);
		}
		else {
			init_prefarray(prefix, field, parent);
		}
		prefix = prefix[field];
		parent = field;
	}
	return prefix;
}

// Set to trigger callbacks when setting preferences
var callbacks_enabled = false;

// These functions are exported
function pref(prefname, value)
{
	var pref = init_preftree(prefname);
	pref.default_value = value;
}

// These three for use by autoconfig file
function defaultPref(prefname, value)
{
	// This routine no longer unlocks the pref
	var pref = init_preftree(prefname);
	var changed = pref.default_value != value &&
		(pref.user_value == null || pref.locked);
	
	pref.default_value = value;
	
	if (callbacks_enabled && changed)
		pref_changed(prefname);
}

function lockPref(prefname, value)
{
	// Set default pref and lock it
	var pref = init_preftree(prefname);
	var changed = !pref.locked || pref.default_value != value;
	
	pref.default_value = value;
	pref.locked = true;

	if (bAnyPrefLocked == false && changed) {
		bAnyPrefLocked = true;
		prefLocked();
	}

	if (callbacks_enabled && changed) {
		pref_changed(prefname);
	}
}

function unlockPref(prefname)
{
	var pref = init_preftree(prefname);
	var changed = pref.locked;
	
	pref.locked = false;

	if (callbacks_enabled && changed)
		pref_changed(prefname);
}

function getPref(prefname)
{
	var pref = init_preftree(prefname);
	return get_user_pref(pref);
}

// 'user_pref' was used in public b2 so keep it
function user_pref(prefname, value)
{
	var pref = init_preftree(prefname);
	if (pref.user_value != value) {
		pref.user_value = value;
		if (callbacks_enabled && !pref.locked)
			pref_changed(prefname);
	}
}

// stubs for compatability
var default_pref = defaultPref;
var lock_pref = lockPref;
var unlock_pref = unlockPref;
var userPref = user_pref;

// -------------------------
prefs = new pref_array(null); 


// -------------------------
function mime_type1(parent)
{
	this.parent = parent;
	this.mimetype = new preference("");
	this.extension = new preference("");
	this.load_action = new preference(0);
	this.mac_appname = new preference("");
	this.mac_appsig = new preference("????");
	this.mac_filetype = new preference("????");
	this.mac_plugin_name = new preference("");
	this.description = new preference("");
	this.latent_plug_in = new preference(false);
}

function mime_type(root, mimetype, extension, load_action, appname, appsig, filetype)
{
	init_preftree(root + ".mimetype");
	var mime = init_preftree(root);

	mime.mimetype.default_value = mimetype;
	mime.extension.default_value = extension;
	mime.load_action.default_value = load_action;
	mime.mac_appsig.default_value = appsig;
	mime.mac_appname.default_value = appname;
	mime.mac_filetype.default_value = filetype;
}

// ---
// This is like the func in prefapi, to escape \ and "
function str_escape(str)
{
	var outstr = "";
	var next = 0;
	while (next < str.length) {
		var c1 = str.indexOf('\\', next); 
		var c2 = str.indexOf('\"', next);
		if (c1 == -1 && c2 == -1) {
			outstr += str.substring(next, str.length);
			next = str.length;
		}
		else {
			var start = next;
			if (c1 == -1)
				next = c2;
			else if (c2 == -1)
				next = c1;
			else
				next = Math.min(c1, c2);
			outstr += str.substring(start, next) + "\\" + str.charAt(next);
			next++;
		}
	}
	return outstr;
}

function save_uservals(obj, obj_name)
{
    var result = ""; 
    var bGroup = false; 
	var eol = "\r";

	if (platform.windows) eol = "\n";

    for (var i in obj) {
       if (i == "parent") bGroup = true; 
		if (i != "parent") {
           if ((i == "user_value") && (obj[i] != null) &&
           	   (obj.user_value != obj.default_value))
            {
				result += "user_pref(\"" + obj_name + "\", ";
				
				if (typeof(obj[i]) == "string")
					result += "\"" + str_escape(obj[i]) + "\");";
				else
					// number or boolean
					result += obj[i] + ");";
				result += eol;
			}
			if (bGroup) {
				if (obj_name.length == 0)
					result += save_uservals(obj[i], i);
				else
					result += save_uservals(obj[i], obj_name + "." + i);
			}
		}
	}
	return result; 
}

// -- For building child iterator
function get_children(node, nodename)
{
	var result = "";
	for (var i in node) {
		if (i != "parent" && node[i] != null) {
			result += nodename + "." + i + ";"
		}
	}
	return result;
}

// -- Admin Kit support --
configs = new pref_array(null);

function config(param, value)
{
	init_configtree(param, value);
}

function init_configtree(param, value)
{
	var index = 0;
	var prefix = configs;
	while (index < param.length)
	{
		field = next_field(param, index);
		index = index + field.length + 1;
		
		if (index >= param.length && value != null) {
			prefix[field] = value;
		}
		else if (typeof(prefix[field]) == "undefined") {
			if (value != null)
				prefix[field] = new pref_array(prefix);
			else
				return null;
		}
		prefix = prefix[field];
	}
	return prefix;
}

// -- These functions are called from within prefapi.c
// -- Returns true iff the pref's value has changed.
// (Set creates the pref if necessary; Get assumes it already exists)
function set_user_pref(prefname, value)
{
	var pref = init_preftree(prefname);
	
	if (pref.locked)
		return false;
		
	if (pref.default_value == value) {
		if (pref.user_value == null)
			return false;
		else {
			pref.user_value = null;
			return true;
		}
	}
	
	if (pref.user_value == value) {
		return false;
	} else {
		pref.user_value = value;
		return true;
	}
}

function get_user_pref(obj)
{
	if (obj.locked || obj.user_value == null) {
		return obj.default_value;
	}
	else {
		return obj.user_value;
	}
}

function set_default_user_pref(prefname, value)
{
	var pref = init_preftree(prefname);
	
	if (!pref.locked && pref.default_value != value) {
		pref.default_value = value;
		return true;
	}
	return false;
}

function get_config(param)
{
	return init_configtree(param, null);
}

// LDAP
// Searches for "key=value" in the given string and returns value.
function getLDAPValue(str, key)
{
	if (str == null || key == null)
		return null;
		
	var search_key = "\n" + key + "=";

	var start_pos = str.indexOf(search_key);
	if (start_pos == -1)
		return null;
		
	start_pos += search_key.length;
		
	var end_pos = str.indexOf("\n", start_pos);
	if (end_pos == -1)
		end_pos = str.length;
	
	return str.substring(start_pos, end_pos);
}